import { defineStore } from 'pinia'
import { computed } from 'vue'
import { useCacheStore } from './cache.js'
import * as api from '../api/api.js'

export const useBlogStore = defineStore('blog', () => {
  const cacheStore = useCacheStore()

  // ==================== 标签相关 ====================
  
  // 获取所有标签（带缓存）
  const getTags = async (forceRefresh = false) => {
    const cacheType = 'tags'
    
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType)) {
      return cacheStore.getCacheData(cacheType)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType)) {
      return cacheStore.getCacheData(cacheType) || []
    }
    
    try {
      cacheStore.setLoading(cacheType, true)
      const data = await api.getTags()
      
      if (data) {
        cacheStore.setCacheData(cacheType, data)
        return data
      }
      
      return []
    } catch (error) {
      console.error('获取标签失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType) || []
    } finally {
      cacheStore.setLoading(cacheType, false)
    }
  }

  // ==================== 分类相关 ====================
  
  // 获取所有分类（带缓存）
  const getCategories = async (forceRefresh = false) => {
    const cacheType = 'categories'
    
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType)) {
      return cacheStore.getCacheData(cacheType)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType)) {
      return cacheStore.getCacheData(cacheType) || []
    }
    
    try {
      cacheStore.setLoading(cacheType, true)
      const data = await api.getCategories()
      
      if (data) {
        cacheStore.setCacheData(cacheType, data)
        return data
      }
      
      return []
    } catch (error) {
      console.error('获取分类失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType) || []
    } finally {
      cacheStore.setLoading(cacheType, false)
    }
  }

  // ==================== 文章相关 ====================
  
  // 获取文章列表（带缓存）
  const getArticles = async (params = {}, forceRefresh = false) => {
    const cacheType = 'articles'
    const cacheKey = cacheStore.generateArticleKey(params)
    console.log(cacheKey);
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType, cacheKey)) {
      return cacheStore.getCacheData(cacheType, cacheKey)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType, cacheKey)) {
      return cacheStore.getCacheData(cacheType, cacheKey) || { list: [], total: 0 }
    }
    
    try {
      cacheStore.setLoading(cacheType, true, cacheKey)
      const data = await api.getArticles(params)
      
      if (data) {
        cacheStore.setCacheData(cacheType, data, cacheKey)
        return data
      }
      
      return { list: [], total: 0 }
    } catch (error) {
      console.error('获取文章列表失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType, cacheKey) || { list: [], total: 0 }
    } finally {
      cacheStore.setLoading(cacheType, false, cacheKey)
    }
  }

  // 获取文章详情（带缓存）
  const getArticleDetail = async (id, forceRefresh = false) => {
    const cacheType = 'articles'
    const cacheKey = `detail:${id}`
    
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType, cacheKey)) {
      return cacheStore.getCacheData(cacheType, cacheKey)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType, cacheKey)) {
      return cacheStore.getCacheData(cacheType, cacheKey) || null
    }
    
    try {
      cacheStore.setLoading(cacheType, true, cacheKey)
      const data = await api.getArticleDetail(id)
      
      if (data) {
        cacheStore.setCacheData(cacheType, data, cacheKey)
        return data
      }
      
      return null
    } catch (error) {
      console.error('获取文章详情失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType, cacheKey) || null
    } finally {
      cacheStore.setLoading(cacheType, false, cacheKey)
    }
  }

  // ==================== 个人信息相关 ====================
  
  // 获取个人信息（带缓存）
  const getPersonalInfo = async (forceRefresh = false) => {
    const cacheType = 'personalInfo'
    
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType)) {
      return cacheStore.getCacheData(cacheType)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType)) {
      return cacheStore.getCacheData(cacheType) || null
    }
    
    try {
      cacheStore.setLoading(cacheType, true)
      const data = await api.getPersonalInfo()
      
      if (data) {
        cacheStore.setCacheData(cacheType, data)
        return data
      }
      
      return null
    } catch (error) {
      console.error('获取个人信息失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType) || null
    } finally {
      cacheStore.setLoading(cacheType, false)
    }
  }

  // ==================== 备案信息相关 ====================
  
  // 获取备案信息（带缓存）
  const getRecordInfo = async (forceRefresh = false) => {
    const cacheType = 'recordInfo'
    
    // 如果缓存有效且不强制刷新，直接返回缓存数据
    if (!forceRefresh && cacheStore.isCacheValid(cacheType)) {
      return cacheStore.getCacheData(cacheType)
    }
    
    // 如果正在加载，返回当前缓存数据（如果有）
    if (cacheStore.getLoading(cacheType)) {
      return cacheStore.getCacheData(cacheType) || null
    }
    
    try {
      cacheStore.setLoading(cacheType, true)
      const data = await api.getRecordInfo()
      
      if (data && data.recordInfo) {
        cacheStore.setCacheData(cacheType, data.recordInfo)
        return data.recordInfo
      }
      
      return null
    } catch (error) {
      console.error('获取备案信息失败:', error)
      // 如果请求失败，返回缓存数据（如果有）
      return cacheStore.getCacheData(cacheType) || null
    } finally {
      cacheStore.setLoading(cacheType, false)
    }
  }

  // ==================== 计算属性 ====================
  
  // 获取加载状态
  const isTagsLoading = computed(() => cacheStore.getLoading('tags'))
  const isCategoriesLoading = computed(() => cacheStore.getLoading('categories'))
  const isPersonalInfoLoading = computed(() => cacheStore.getLoading('personalInfo'))
  const isRecordInfoLoading = computed(() => cacheStore.getLoading('recordInfo'))
  
  // 获取缓存数据
  const cachedTags = computed(() => cacheStore.getCacheData('tags') || [])
  const cachedCategories = computed(() => cacheStore.getCacheData('categories') || [])
  const cachedPersonalInfo = computed(() => cacheStore.getCacheData('personalInfo'))
  const cachedRecordInfo = computed(() => cacheStore.getCacheData('recordInfo'))

  // ==================== 缓存管理方法 ====================
  
  // 清除指定类型的缓存
  const clearCache = (type, key = null) => {
    cacheStore.clearCache(type, key)
  }
  
  // 清除所有缓存
  const clearAllCache = () => {
    cacheStore.clearAllCache()
  }
  
  // 预加载常用数据
  const preloadData = async () => {
    try {
      // 并行加载标签和分类数据
      await Promise.all([
        getTags(),
        getCategories()
      ])
    } catch (error) {
      console.error('预加载数据失败:', error)
    }
  }

  return {
    // 数据获取方法
    getTags,
    getCategories,
    getArticles,
    getArticleDetail,
    getPersonalInfo,
    getRecordInfo,
    
    // 计算属性
    isTagsLoading,
    isCategoriesLoading,
    isPersonalInfoLoading,
    isRecordInfoLoading,
    cachedTags,
    cachedCategories,
    cachedPersonalInfo,
    cachedRecordInfo,
    
    // 缓存管理
    clearCache,
    clearAllCache,
    preloadData
  }
})